home *** CD-ROM | disk | FTP | other *** search
/ Aminet 6 / Aminet 6 - June 1995.iso / Aminet / gfx / 3d / irit50src.lha / irit5 / prsr_lib / bzr_read.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-29  |  14.5 KB  |  386 lines
  1. /******************************************************************************
  2. * Bzr_Read.c - Bezier handling routines - read from file.              *
  3. *******************************************************************************
  4. * Written by Gershon Elber, Mar. 90.                          *
  5. ******************************************************************************/
  6.  
  7. #include <ctype.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include "prsr_loc.h"
  11.  
  12. /*****************************************************************************
  13. * DESCRIPTION:                                                               M
  14. * Reads from a file Bezier curve(s).                         M
  15. *   If error is detected in reading the file, ErrStr is set to a string      M
  16. * describing the error and Line to the line it occured in file.             M
  17. *   If no error is detected *ErrStr = NULL.                     M
  18. *                                                                            *
  19. * PARAMETERS:                                                                M
  20. *   FileName:     To read the Bezier curve from.                             M
  21. *   ErrStr:       Will be initialized if an error has occured.               M
  22. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  23. *                                                                            *
  24. * RETURN VALUE:                                                              M
  25. *   CagdCrvStruct *: The read curve, or NULL if an error occured.            M
  26. *                                                                            *
  27. * KEYWORDS:                                                                  M
  28. *   BzrCrvReadFromFile, files, read                                          M
  29. *****************************************************************************/
  30. CagdCrvStruct *BzrCrvReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  31. {
  32.     int Handler;
  33.     FILE *f;
  34.     char StringToken[LINE_LEN];
  35.     CagdCrvStruct *Crv,
  36.     *CrvTail = NULL,
  37.     *CrvList = NULL;
  38.  
  39.     if ((f = fopen(FileName, "r")) == NULL) {
  40.     *ErrStr = "File not found";
  41.     *ErrLine = 0;
  42.     return NULL;
  43.     }
  44.     Handler = IritPrsrOpenStreamFromFile(f, TRUE,
  45.                      IritPrsrSenseBinaryFile(FileName),
  46.                      FALSE);
  47.  
  48.     while (_IPGetToken(Handler, StringToken) == IP_TOKEN_OPEN_PAREN) {
  49.     _IPUnGetToken(Handler, StringToken);
  50.         Crv = BzrCrvReadFromFile2(Handler, FALSE, ErrStr, ErrLine);
  51.  
  52.     if (CrvList == NULL)
  53.         CrvList = CrvTail = Crv;
  54.     else {
  55.         CrvTail -> Pnext = Crv;
  56.         CrvTail = Crv;
  57.     }
  58.     }
  59.  
  60.     IritPrsrCloseStream(Handler, TRUE);
  61.  
  62.     return CrvList;
  63. }
  64.  
  65. /*****************************************************************************
  66. * DESCRIPTION:                                                               M
  67. * Reads from a file a Bezier curve.                         M
  68. *   If NameWasRead is TRUE, it is assumed prefix "[CURVE BEZIER" has         M
  69. * already been read. This is useful for a global parser which invokes this   M
  70. * routine to read from a file several times as a parent controller.          M
  71. *   For exactly this reason, the given file descriptor is NOT closed in the  M
  72. * end.                                         M
  73. *   If error is found in reading the file, ErrStr is set to a string         M
  74. * describing it and ErrLine to line it occured in file relative to begining  M
  75. * of curve.                                      M
  76. *   If no error is detected *ErrStr is set to NULL.                 M
  77. *                                                                            *
  78. * PARAMETERS:                                                                M
  79. *   Handler:      A handler to the open stream.                     M
  80. *   NameWasRead:  TRUE if "[CURVE BEZIER" hasbeen read, FALSE otherwise.     M
  81. *   ErrStr:       Will be initialized if an error has occured.               M
  82. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  83. *                                                                            *
  84. * RETURN VALUE:                                                              M
  85. *   CagdCrvStruct *: The read curve, or NULL if an error occured.            M
  86. *                                                                            *
  87. * KEYWORDS:                                                                  M
  88. *   BzrCrvReadFromFile2, files, read, stream                                 M
  89. *****************************************************************************/
  90. CagdCrvStruct *BzrCrvReadFromFile2(int Handler,
  91.                    CagdBType NameWasRead,
  92.                    char **ErrStr,
  93.                    int *ErrLine)
  94. {
  95.     CagdPointType PType;
  96.     IPTokenType Token;
  97.     int i, j, Length, MaxCoord;
  98.     char StringToken[LINE_LEN];
  99.     CagdCrvStruct *NewCrv;
  100.  
  101.     if (!NameWasRead) {
  102.     while ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_EOF &&
  103.            Token != IP_TOKEN_OPEN_PAREN);
  104.  
  105.     /* We found beginning of definition - read one: */
  106.     if (_IPGetToken(Handler, StringToken) != IP_TOKEN_CURVE ||
  107.         _IPGetToken(Handler, StringToken) != IP_TOKEN_BEZIER) {
  108.             *ErrStr = "CURVE BEZIER key words expected";
  109.         *ErrLine = _IPStream[Handler].LineNum;
  110.         return NULL;
  111.     }
  112.     }
  113.  
  114.     if ((Token = _IPGetToken(Handler, StringToken)) == IP_TOKEN_OPEN_PAREN) {
  115.     if ((*ErrStr = _IPGetCurveAttributes(Handler)) != NULL) {
  116.             *ErrStr = "\"[\" expected";
  117.         *ErrLine = _IPStream[Handler].LineNum;
  118.         return NULL;
  119.     }
  120.     }
  121.     else
  122.     _IPUnGetToken(Handler, StringToken);
  123.  
  124.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  125.     sscanf(StringToken, "%d", &Length) != 1) {
  126.     *ErrStr = "BEZIER Number of points expected";
  127.     *ErrLine = _IPStream[Handler].LineNum;
  128.     return NULL;
  129.     }
  130.  
  131.     Token = _IPGetToken(Handler, StringToken);
  132.     if (!IP_IS_TOKEN_POINT(Token) ||
  133.     strlen(StringToken) != 2 ||
  134.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  135.     !isdigit(StringToken[1]) ||
  136.     atoi(&StringToken[1]) > CAGD_MAX_PT_COORD) {
  137.     *ErrStr = "BEZIER Point type expected";
  138.     *ErrLine = _IPStream[Handler].LineNum;
  139.     return NULL;
  140.     }
  141.  
  142.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  143.  
  144.     NewCrv = BzrCrvNew(Length, PType);
  145.  
  146.     /* Read the points themselves: */
  147.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  148.     for (i = 0; i < Length; i++) {
  149.     if ((Token = _IPGetToken(Handler, StringToken)) !=
  150.                             IP_TOKEN_OPEN_PAREN) {
  151.         *ErrStr = "\"[\" expected";
  152.         *ErrLine = _IPStream[Handler].LineNum;
  153.         CagdCrvFree(NewCrv);
  154.         return NULL;
  155.     }
  156.     if (CAGD_IS_RATIONAL_PT(PType)) {
  157.         if ((Token = _IPGetToken(Handler, StringToken)) !=
  158.                                   IP_TOKEN_OTHER ||
  159.         sscanf(StringToken, IP_FLOAT_READ,
  160.                            &NewCrv -> Points[0][i]) != 1) {
  161.         *ErrStr = "Numeric data expected";
  162.         *ErrLine = _IPStream[Handler].LineNum;
  163.         CagdCrvFree(NewCrv);
  164.         return NULL;
  165.         }
  166.     }
  167.     for (j = 1; j <= MaxCoord; j++) {
  168.         if ((Token = _IPGetToken(Handler, StringToken)) !=
  169.                                   IP_TOKEN_OTHER ||
  170.         sscanf(StringToken, IP_FLOAT_READ,
  171.                            &NewCrv -> Points[j][i]) != 1) {
  172.         *ErrStr = "Numeric data expected";
  173.         *ErrLine = _IPStream[Handler].LineNum;
  174.         CagdCrvFree(NewCrv);
  175.         return NULL;
  176.         }
  177.     }
  178.     if ((Token = _IPGetToken(Handler, StringToken)) !=
  179.                                IP_TOKEN_CLOSE_PAREN) {
  180.         *ErrStr = "\"]\" expected";
  181.         *ErrLine = _IPStream[Handler].LineNum;
  182.         CagdCrvFree(NewCrv);
  183.         return NULL;
  184.     }
  185.     }
  186.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_CLOSE_PAREN) {
  187.     *ErrStr = "\"]\" expected";
  188.     *ErrLine = _IPStream[Handler].LineNum;
  189.     CagdCrvFree(NewCrv);
  190.     return NULL;
  191.     }
  192.  
  193.     *ErrLine = _IPStream[Handler].LineNum;
  194.     *ErrStr = NULL;
  195.  
  196.     return NewCrv;
  197. }
  198.  
  199. /*****************************************************************************
  200. * DESCRIPTION:                                                               M
  201. * Reads from a file Bezier surface(s).                         M
  202. *   If error is detected in reading the file, ErrStr is set to a string      M
  203. * describing the error and Line to the line it occured in file.             M
  204. *   If no error is detected *ErrStr = NULL.                     M
  205. *                                                                            *
  206. * PARAMETERS:                                                                M
  207. *   FileName:     To read the Bezier surface from.                           M
  208. *   ErrStr:       Will be initialized if an error has occured.               M
  209. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  210. *                                                                            *
  211. * RETURN VALUE:                                                              M
  212. *   CagdSrfStruct *: The read surface, or NULL if an error occured.          M
  213. *                                                                            *
  214. * KEYWORDS:                                                                  M
  215. *   BzrSrfReadFromFile, files, read                                          M
  216. *****************************************************************************/
  217. CagdSrfStruct *BzrSrfReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  218. {
  219.     int Handler;
  220.     FILE *f;
  221.     char StringToken[LINE_LEN];
  222.     CagdSrfStruct *Srf,
  223.     *SrfTail = NULL,
  224.     *SrfList = NULL;
  225.  
  226.     if ((f = fopen(FileName, "r")) == NULL) {
  227.     *ErrStr = "File not found";
  228.     *ErrLine = 0;
  229.     return NULL;
  230.     }
  231.     Handler = IritPrsrOpenStreamFromFile(f, TRUE,
  232.                      IritPrsrSenseBinaryFile(FileName),
  233.                      FALSE);
  234.  
  235.     while (_IPGetToken(Handler, StringToken) == IP_TOKEN_OPEN_PAREN) {
  236.     _IPUnGetToken(Handler, StringToken);
  237.         Srf = BzrSrfReadFromFile2(Handler, FALSE, ErrStr, ErrLine);
  238.  
  239.     if (SrfList == NULL)
  240.         SrfList = SrfTail = Srf;
  241.     else {
  242.         SrfTail -> Pnext = Srf;
  243.         SrfTail = Srf;
  244.     }
  245.     }
  246.  
  247.     IritPrsrCloseStream(Handler, TRUE);
  248.  
  249.     return SrfList;
  250. }
  251.  
  252. /*****************************************************************************
  253. * DESCRIPTION:                                                               M
  254. * Reads from a file a Bezier surface.                         M
  255. *   If NameWasRead is TRUE, it is assumed prefix "[SURFACE BEZIER" has       M
  256. * already been read. This is useful for a global parser which invokes this   M
  257. * routine to read from a file several times as a parent controller.          M
  258. *   For exactly this reason, the given file descriptor is NOT closed in the  M
  259. * end.                                         M
  260. *   If error is found in reading the file, ErrStr is set to a string         M
  261. * describing it and ErrLine to line it occured in file relative to begining  M
  262. * of surface.                                      M
  263. *   If no error is detected *ErrStr is set to NULL.                 M
  264. *                                                                            *
  265. * PARAMETERS:                                                                M
  266. *   Handler:      A handler to the open stream.                     M
  267. *   NameWasRead: TRUE if "[SURFACE BEZIER" hasbeen read, FALSE otherwise.    M
  268. *   ErrStr:       Will be initialized if an error has occured.               M
  269. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  270. *                                                                            *
  271. * RETURN VALUE:                                                              M
  272. *   CagdSrfStruct *: The read surface, or NULL if an error occured.          M
  273. *                                                                            *
  274. * KEYWORDS:                                                                  M
  275. *   BzrSrfReadFromFile2, files, read, stream                                 M
  276. *****************************************************************************/
  277. CagdSrfStruct *BzrSrfReadFromFile2(int Handler,
  278.                    CagdBType NameWasRead,
  279.                    char **ErrStr,
  280.                    int *ErrLine)
  281. {
  282.     CagdPointType PType;
  283.     IPTokenType Token;
  284.     int i, j, ULength, VLength, MaxCoord;
  285.     char StringToken[LINE_LEN];
  286.     CagdSrfStruct *NewSrf;
  287.  
  288.     if (!NameWasRead) {
  289.     while ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_EOF &&
  290.            Token != IP_TOKEN_OPEN_PAREN);
  291.  
  292.     /* We found beginning of definition - read one: */
  293.     if (_IPGetToken(Handler, StringToken) != IP_TOKEN_SURFACE ||
  294.         _IPGetToken(Handler, StringToken) != IP_TOKEN_BEZIER) {
  295.         *ErrStr = "SURFACE BEZIER key words expected";
  296.         *ErrLine = _IPStream[Handler].LineNum;
  297.         return NULL;
  298.         }
  299.     }
  300.  
  301.     if ((Token = _IPGetToken(Handler, StringToken)) == IP_TOKEN_OPEN_PAREN) {
  302.     if ((*ErrStr = _IPGetSurfaceAttributes(Handler)) != NULL) {
  303.         *ErrStr = "\"[\" expected";
  304.         *ErrLine = _IPStream[Handler].LineNum;
  305.         return NULL;
  306.     }
  307.     }
  308.     else
  309.     _IPUnGetToken(Handler, StringToken);
  310.  
  311.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  312.         sscanf(StringToken, "%d", &ULength) != 1 ||
  313.     (Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  314.     sscanf(StringToken, "%d", &VLength) != 1) {
  315.     *ErrStr = "BEZIER Number of points expected";
  316.     *ErrLine = _IPStream[Handler].LineNum;
  317.     return NULL;
  318.     }
  319.  
  320.     Token = _IPGetToken(Handler, StringToken);
  321.     if (!IP_IS_TOKEN_POINT(Token) ||
  322.         strlen(StringToken) != 2 ||
  323.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  324.     !isdigit(StringToken[1]) ||
  325.     atoi(&StringToken[1]) > CAGD_MAX_PT_COORD) {
  326.     *ErrStr = "BEZIER Point type expected";
  327.     *ErrLine = _IPStream[Handler].LineNum;
  328.     return NULL;
  329.     }
  330.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  331.  
  332.     NewSrf = BzrSrfNew(ULength, VLength, PType);
  333.  
  334.     /* Read the points themselves: */
  335.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  336.     for (i = 0; i < ULength * VLength; i++) {
  337.     if ((Token = _IPGetToken(Handler, StringToken)) !=
  338.                             IP_TOKEN_OPEN_PAREN) {
  339.         *ErrStr = "\"[\" expected";
  340.         *ErrLine = _IPStream[Handler].LineNum;
  341.         CagdSrfFree(NewSrf);
  342.         return NULL;
  343.     }
  344.     if (CAGD_IS_RATIONAL_PT(PType)) {
  345.         if ((Token = _IPGetToken(Handler, StringToken)) !=
  346.                                  IP_TOKEN_OTHER ||
  347.             sscanf(StringToken, IP_FLOAT_READ,
  348.                     &NewSrf -> Points[0][i]) != 1) {
  349.         *ErrStr = "Numeric data expected";
  350.         *ErrLine = _IPStream[Handler].LineNum;
  351.         CagdSrfFree(NewSrf);
  352.         return NULL;
  353.         }
  354.     }
  355.     for (j = 1; j <= MaxCoord; j++) {
  356.         if ((Token = _IPGetToken(Handler, StringToken)) !=
  357.                                   IP_TOKEN_OTHER ||
  358.             sscanf(StringToken, IP_FLOAT_READ,
  359.                            &NewSrf -> Points[j][i]) != 1) {
  360.         *ErrStr = "Numeric data expected";
  361.         *ErrLine = _IPStream[Handler].LineNum;
  362.         CagdSrfFree(NewSrf);
  363.         return NULL;
  364.         }
  365.     }
  366.     if ((Token = _IPGetToken(Handler, StringToken)) !=
  367.                                IP_TOKEN_CLOSE_PAREN) {
  368.         *ErrStr = "\"]\" expected";
  369.         *ErrLine = _IPStream[Handler].LineNum;
  370.         CagdSrfFree(NewSrf);
  371.         return NULL;
  372.     }
  373.     }
  374.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_CLOSE_PAREN) {
  375.         *ErrStr = "\"]\" expected";
  376.     *ErrLine = _IPStream[Handler].LineNum;
  377.     CagdSrfFree(NewSrf);
  378.     return NULL;
  379.     }
  380.  
  381.     *ErrStr = NULL;
  382.     *ErrLine = _IPStream[Handler].LineNum;
  383.  
  384.     return NewSrf;
  385. }
  386.